import { Configuration, AuthApi, UsersApi, PermissionsApi, AiChatApi } from './generated/src/index';
import { API_CONFIG } from './config';
import { message } from 'antd';

// Token管理器
export const tokenManager = {
  getToken: (): string | null => localStorage.getItem('access_token'),
  setToken: (token: string): void => localStorage.setItem('access_token', token),
  removeToken: (): void => localStorage.removeItem('access_token'),
  getRefreshToken: (): string | null => localStorage.getItem('refresh_token'),
  setRefreshToken: (token: string): void => localStorage.setItem('refresh_token', token),
  clearToken: (): void => {
    localStorage.removeItem('access_token');
    localStorage.removeItem('refresh_token');
  },
};

// 白名单接口（不需要认证）
const isPublicEndpoint = (url: string): boolean => {
  const publicPaths = ['/auth/token/', '/auth/register/', '/health/', '/docs/', '/schema/'];
  return publicPaths.some(path => url.includes(path));
};

// 获取字段的显示名称（中文）
const getFieldDisplayName = (fieldName: string): string => {
  const fieldNameMap: Record<string, string> = {
    // 用户相关字段
    username: '用户名',
    email: '邮箱',
    password: '密码',
    password_confirm: '确认密码',
    real_name: '真实姓名',
    phone: '手机号',
    old_password: '原密码',
    new_password: '新密码',
    new_password_confirm: '确认新密码',

    // 通用字段
    name: '名称',
    title: '标题',
    description: '描述',
    content: '内容',
    status: '状态',

    // 其他常用字段
    non_field_errors: '表单',
    detail: '详情',
  };

  return fieldNameMap[fieldName] || fieldName;
};

// 处理API错误响应的函数
const handleApiErrorResponse = async (response: Response): Promise<void> => {
  if (!response.ok && response.status >= 400 && response.status < 500) {
    try {
      const errorData = await response.clone().json();

      if (errorData?.errors && typeof errorData.errors === 'object') {
        // 处理字段级别的错误
        const errorMessages: string[] = [];

        Object.keys(errorData.errors).forEach(field => {
          const fieldErrors = errorData.errors[field];
          if (Array.isArray(fieldErrors)) {
            // 如果是数组，合并所有错误信息
            fieldErrors.forEach(err => {
              errorMessages.push(`${getFieldDisplayName(field)}: ${err}`);
            });
          } else if (typeof fieldErrors === 'string') {
            // 如果是字符串，直接添加
            errorMessages.push(`${getFieldDisplayName(field)}: ${fieldErrors}`);
          }
        });

        if (errorMessages.length > 0) {
          // 显示所有错误信息
          errorMessages.forEach(msg => {
            message.error(msg);
          });
          return;
        }
      }

      // 如果没有详细错误信息，显示通用消息
      if (errorData?.message) {
        message.error(errorData.message);
      }
    } catch (e) {
      // JSON解析失败，显示默认错误
      console.error('解析错误响应失败:', e);
    }
  }
};

// API配置 - 使用全局配置
const createApiConfiguration = (): Configuration => {
  return new Configuration({
    basePath: API_CONFIG.basePath,  // 🔑 关键：使用全局配置
    middleware: [
      {
        pre: async (context) => {
          const url = context.url;

          // 只有非公开接口才添加认证头
          if (!isPublicEndpoint(url)) {
            const currentToken = tokenManager.getToken();
            if (currentToken && context.init.headers) {
              (context.init.headers as any)['Authorization'] = `Bearer ${currentToken}`;
            }
          }

          return Promise.resolve(context);
        },
        post: async (context) => {
          const response = context.response;
          
          // 处理401未授权错误
          if (response.status === 401 && !isPublicEndpoint(context.url)) {
            const refreshed = await handleTokenRefresh();
            if (refreshed) {
              // 重新发送请求
              const newHeaders = { ...context.init.headers } as any;
              newHeaders['Authorization'] = `Bearer ${tokenManager.getToken()}`;

              return fetch(context.url, {
                ...context.init,
                headers: newHeaders,
              });
            } else {
              // 跳转到登录页
              window.location.href = '/login';
            }
          }

          // 处理其他错误响应（400-499）
          await handleApiErrorResponse(response);

          return response;
        }
      }
    ]
  });
};

// 导出API客户端 - 按后端应用模块划分
export const apiClients = {
  // 🔑 关键：每个后端应用对应专门的API客户端类
  auth: new AuthApi(createApiConfiguration()),
  users: new UsersApi(createApiConfiguration()),
  permissions: new PermissionsApi(createApiConfiguration()),
  aiChat: new AiChatApi(createApiConfiguration()),
  // 根据实际后端应用添加更多: system, etc.
  // ❌ 禁止使用通用的DefaultApi
};

// Token刷新处理 - 直接使用已有的API客户端
const handleTokenRefresh = async (): Promise<boolean> => {
  const refreshToken = tokenManager.getRefreshToken();
  if (!refreshToken) return false;

  try {
    // 使用已配置的API客户端
    const response = await apiClients.auth.authTokenRefreshCreate({
      tokenRefreshRequest: { refresh: refreshToken }
    });

    // 手动提取响应数据
    const tokenData = response.data;
    if (tokenData?.access) {
      tokenManager.setToken(tokenData.access);
      return true;
    }
  } catch (error) {
    console.error('Token刷新失败:', error);
  }

  // 刷新失败，清除所有token
  tokenManager.removeToken();
  return false;
};

// 导出手动错误处理函数，供特殊场景使用
export const handleApiError = async (error: any, defaultMessage: string = '操作失败'): Promise<void> => {
  console.error('API错误:', error);

  const response = error?.response;
  if (response) {
    await handleApiErrorResponse(response);
  } else {
    message.error(defaultMessage);
  }
};

// 登出功能
export const logout = async (): Promise<void> => {
  try {
    // TODO: 等API客户端重新生成后调用后端登出接口
    // await apiClients.users.usersLogoutCreate({});
    console.log('用户登出');
  } catch (error) {
    console.error('登出接口调用失败:', error);
    // 即使接口失败也继续清理本地数据
  } finally {
    // 清除本地存储的Token
    tokenManager.clearToken();
    // 使用强制刷新跳转到登录页，确保清除所有状态
    window.location.replace('/user/login');
  }
};
